package Entity;

import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.Scanner;

/**
 * 练习会话管理类：最终版（彻底修复方法名+参数匹配问题）
 */
public class PracticeSession {
    private final PracticeManager practiceManager;
    private String currentPracticeFile;
    private List<PracticeRecord> currentRecords;
    private List<Exercise> currentExercises;

    public PracticeSession() {
        this.practiceManager = new PracticeManager();
    }

    /**
     * 开始新练习（核心修复：方法名+参数完全匹配 PracticeManager）
     * @param exerciseFilePath 习题文件路径（仅需1个参数，练习者姓名已在 PracticeManager 中固定）
     */
    public void startNewPractice(String exerciseFilePath) throws IOException {
        // 1. 调用 PracticeManager 中真实存在的方法：startPracticeByExerciseFile（仅1个参数）
        currentPracticeFile = practiceManager.startPracticeByExerciseFile(exerciseFilePath);
        // 2. 加载习题和练习记录
        loadPracticeData(exerciseFilePath);
        // 3. 开始答题流程
        startAnswering();
    }

    /**
     * 恢复之前的练习（无修改，确保参数正确）
     * @param practiceFilePath 已存在的练习文件路径
     * @param exerciseFilePath 对应的习题文件路径（必须与练习文件关联）
     */
    public void resumePractice(String practiceFilePath, String exerciseFilePath) throws IOException {
        // 验证练习文件存在
        if (!new File(practiceFilePath).exists()) {
            throw new IllegalArgumentException("练习文件不存在：" + practiceFilePath);
        }
        currentPracticeFile = practiceFilePath;
        // 加载习题和练习记录
        loadPracticeData(exerciseFilePath);
        // 开始答题流程（跳过已完成题目）
        startAnswering();
    }

    /**
     * 加载练习所需数据（习题+练习记录）
     */
    private void loadPracticeData(String exerciseFilePath) throws IOException {
        currentExercises = CsvFileUtil.readExercises(exerciseFilePath);
        currentRecords = CsvFileUtil.readPracticeRecords(currentPracticeFile);
    }

    /**
     * 答题主流程（支持中断保存/恢复）
     */
    private void startAnswering() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("===== 开始练习 =====");
        System.out.println("提示：输入答案后按回车提交，输入'q'可中断练习并保存进度");

        for (int i = 0; i < currentRecords.size(); i++) {
            PracticeRecord record = currentRecords.get(i);
            Exercise exercise = findExerciseById(record.getExerciseId());

            // 跳过已完成的题目（适配 Integer 类型的 null 判断）
            if (record.isCompleted() && record.getUserAnswer() != null) {
                System.out.printf("\n第%d题（已完成）：%d %c %d = ? 你的答案：%d\n",
                        i + 1,
                        exercise.getNum1(),
                        exercise.getOperator(),
                        exercise.getNum2(),
                        record.getUserAnswer());
                continue;
            }

            // 显示当前题目并获取答案
            System.out.printf("\n第%d题：%d %c %d = ? 请输入答案：",
                    i + 1,
                    exercise.getNum1(),
                    exercise.getOperator(),
                    exercise.getNum2());

            String input = scanner.nextLine().trim();
            // 处理中断命令（输入q/Q中断）
            if (input.equalsIgnoreCase("q")) {
                System.out.println("已中断练习，进度已保存");
                break;
            }

            // 验证输入并保存进度
            try {
                Integer userAnswer = Integer.parseInt(input);
                // 调用正确的保存方法（参数匹配）
                practiceManager.savePracticeProgress(currentPracticeFile, exercise.getExerciseId(), userAnswer);
                // 更新当前内存中的记录（避免重新读取文件）
                record.setUserAnswer(userAnswer);
                record.setCompleted(true);
            } catch (NumberFormatException e) {
                System.out.println("输入错误！请输入有效整数，重新答题：");
                i--; // 重新回答本题
            } catch (IOException e) {
                System.out.println("进度保存失败：" + e.getMessage() + "，重新答题：");
                i--; // 重新回答本题
            }
        }

        // 检查是否全部完成
        boolean allCompleted = currentRecords.stream()
                .allMatch(record -> record.isCompleted() && record.getUserAnswer() != null);
        if (allCompleted) {
            System.out.println("\n===== 恭喜！所有题目已完成 =====");
        }
        scanner.close();
    }

    /**
     * 根据习题ID查找对应的习题（防御性编程）
     */
    private Exercise findExerciseById(String exerciseId) {
        for (Exercise exercise : currentExercises) {
            if (exercise.getExerciseId().equals(exerciseId)) {
                return exercise;
            }
        }
        throw new RuntimeException("练习文件中存在无效习题ID：" + exerciseId + "，请检查习题文件与练习文件是否匹配");
    }

    // 测试方法（最终版：参数正确，方法名正确）
    public static void main(String[] args) {
        try {
            // 步骤1：生成一套测试用加法习题（若已有习题文件，可跳过此步骤）
            ExerciseGenerator generator = ExerciseGenerator.getInstance();
            String testDate = "20231001"; // 测试日期
            generator.generateAddExercises(10, testDate); // 生成10道加法题

            // 步骤2：指定习题文件路径（替换为实际生成的文件路径，可从控制台输出复制）
            String exerciseFile = "D:\\作业\\软件构造\\Exercise_Add_20231001_001.csv";

            // 步骤3：启动新练习（调用修复后的方法，仅传1个参数）
            PracticeSession session = new PracticeSession();
            session.startNewPractice(exerciseFile);

            // 步骤4：恢复练习（测试时注释步骤3，解开以下注释，替换为实际生成的练习文件路径）
            // String practiceFile = "D:\\作业\\软件构造\\Exercise_Add_20231001_001_Xiaoming_20231001.csv";
            // session.resumePractice(practiceFile, exerciseFile);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}